Products
In-IDE
IDE extension that lets you fix coding issues before they exist!
Discover SonarQube for IDE
SaaS
Setup is effortless and analysis is automatic for most languages
Discover SonarQube Cloud
Self-Hosted
Fast, accurate analysis; enterprise scalability
Discover SonarQube Server

Secrets
ABAP
Ansible
Apex
AzureResourceManager
C
C#
C++
CloudFormation
COBOL
CSS
Dart
Docker
Flex
Go
HTML
Java
JavaScript
JCL
Kotlin
Kubernetes
Objective C
PHP
PL/I
PL/SQL
Python
RPG
Ruby
Scala
Swift
Terraform
Text
TypeScript
T-SQL
VB.NET
VB6
XML

Java static code analysis

Unique rules to find Bugs, Vulnerabilities, Security Hotspots, and Code Smells in your JAVA code

Tags

Impact

Clean code attribute

Functions should not be defined with a variable number of arguments
Code Smell
Equality operators should not be used in "for" loop termination conditions
Code Smell
Increment (++) and decrement (--) operators should not be used in a method call or mixed with other operators in an expression
Code Smell
Limited dependence should be placed on operator precedence
Code Smell
Literal suffixes should be upper case
Code Smell
Methods annotated with "@BeforeTransaction" or "@AfterTransaction" must respect the contract
Code Smell
Methods returning "Page" or "Slice" must take "Pageable" as an input parameter
Code Smell
@InitBinder methods should have void return type
Code Smell
"@Cache*" annotations should only be applied on concrete classes
Code Smell
@Cacheable and @CachePut should not be combined
Code Smell
Injecting data into static fields is not supported by Spring
Code Smell
Use appropriate @DirtiesContext modes
Code Smell
"String.isEmpty()" should be used to test for emptiness
Code Smell
Circular dependencies between classes across packages should be resolved
Code Smell
Circular dependencies between classes in the same package should be resolved
Code Smell
Bluetooth should be configured to use low power
Code Smell
Motion Sensor should not use gyroscope
Code Smell
Use when instead of a single if inside a pattern match body
Code Smell
Use Fused Location to optimize battery power
Code Smell
Use batch Processing in JDBC
Code Smell
Constant parameters in a "PreparedStatement" should not be set more than once
Code Smell
SQL queries should retrieve only necessary fields
Code Smell
Avoid using "FetchType.EAGER"
Code Smell
High frame rates should not be used
Code Smell
Exact alarms should not be abused
Code Smell
Proper Sensor Resource Management
Code Smell
Use built-in "Math.clamp" methods
Code Smell
Use switch instead of if-else chain to compare a variable against multiple cases
Code Smell
Use record pattern instead of explicit field access
Code Smell
Reverse view should be used instead of reverse copy in read-only cases
Code Smell
Reverse iteration should utilize reversed view
Code Smell
Superfluous "@ResponseBody" annotations should be removed
Code Smell
"@Controller" should be replaced with "@RestController"
Code Smell
Non-singleton Spring beans should not be injected into singleton beans
Code Smell
Bean names should adhere to the naming conventions
Code Smell
"@Autowired" should be used when multiple constructors are provided
Code Smell
Optional REST parameters should have an object type
Code Smell
Field dependency injection should be avoided
Code Smell
Methods with Spring proxy should not be called via "this"
Code Smell
"@Value" annotation should inject property or SpEL expression
Code Smell
Redundant nullability annotations should be removed
Code Smell
The Singleton design pattern should be used with care
Code Smell
Methods should not perform too many tasks (aka Brain method)
Code Smell
Classes should not depend on an excessive number of classes (aka Monster Class)
Code Smell
Hash-based collections with known capacity should be initialized with the proper related static method.
Code Smell
Types used as keys in Maps should implement Comparable
Code Smell
Character classes in regular expressions should not contain only one character
Code Smell
Superfluous curly brace quantifiers should be avoided
Code Smell
Non-capturing groups without quantifier should not be used
Code Smell
Deprecated annotations should include explanations
Code Smell
Regular expression quantifiers and character classes should be used concisely
Code Smell
Regular expressions should not contain empty groups
Code Smell
Regular expressions should not contain multiple spaces
Code Smell
AWS region should not be set with a hardcoded String
Code Smell
Lambdas should not invoke other lambdas synchronously
Code Smell
Consumer Builders should be used
Code Smell
Reusable resources should be initialized at construction time of Lambda functions
Code Smell
Credentials Provider should be set explicitly when creating a new "AwsClient"
Code Smell
Region should be set explicitly when creating a new "AwsClient"
Code Smell
'serialVersionUID' field should not be set to '0L' in records
Code Smell
Permitted types of a sealed class should be omitted if they are declared in the same file
Code Smell
Restricted Identifiers should not be used as Identifiers
Code Smell
Local-Variable Type Inference should be used
Code Smell
Custom getter method should not be used to override record's getter behavior
Code Smell
Comma-separated labels should be used in Switch with colon case
Code Smell
Redundant constructors/methods should be avoided in records
Code Smell
Records should be used instead of ordinary classes when representing immutable data structure
Code Smell
Switch arrow labels should not use redundant keywords
Code Smell
"Stream.toList()" method should be used instead of "collectors" when unmodifiable list needed
Code Smell
Text blocks should not be used in complex expressions
Code Smell
Operator "instanceof" should be used instead of "A.class.isInstance()"
Code Smell
Pattern Matching for "instanceof" operator should be used instead of simple "instanceof" + cast
Code Smell
String multiline concatenation should be replaced with Text Blocks
Code Smell
Call to Mockito method "verify", "when" or "given" should be simplified
Code Smell
Single-character alternations in regular expressions should be replaced with character classes
Code Smell
Reluctant quantifiers in regular expressions should be followed by an expression that can't match the empty string
Code Smell
Constructors of an "abstract" class should not be declared "public"
Code Smell
Tests should use fixed data instead of randomized data
Code Smell
Similar tests should be grouped in a single Parameterized test
Code Smell
Tests should be stable
Code Smell
Spring's ModelAndViewAssert assertions should be used instead of other assertions
Code Smell
Mocking all non-private methods of a class should be avoided
Code Smell
Test methods should not contain too many assertions
Code Smell
AssertJ "assertThatThrownBy" should not be used alone
Code Smell
Character classes in regular expressions should not contain the same character twice
Code Smell
Unicode-aware versions of character classes should be preferred
Code Smell
Names of regular expressions named groups should be used
Code Smell
Character classes should be preferred over reluctant quantifiers in regular expressions
Code Smell
Regexes containing characters subject to normalization should use the CANON_EQ flag
Code Smell
Consecutive AssertJ "assertThat" statements should be chained
Code Smell
Empty lines should not be tested with regex MULTILINE flag
Code Smell
Regular expressions should not be too complicated
Code Smell
Chained AssertJ assertions should be simplified to the corresponding dedicated assertion
Code Smell
Methods setUp() and tearDown() should be correctly annotated starting with JUnit4
Code Smell
Class members annotated with "@VisibleForTesting" should not be accessed from production code
Code Smell
Migrate your tests from JUnit4 to the new JUnit5 annotations
Code Smell
JUnit5 test classes and methods should have default package visibility
Code Smell
JUnit assertTrue/assertFalse should be simplified to the corresponding dedicated assertion
Code Smell
Only one method invocation is expected when testing runtime exceptions
Code Smell
Exception testing via JUnit @Test annotation should be avoided
Code Smell
Exception testing via JUnit ExpectedException rule should not be mixed with other assertions
Code Smell
"@Deprecated" code marked for removal should never be used
Code Smell
Vararg method arguments should not be confusing
Code Smell
Escape sequences should not be used in text blocks
Code Smell
Whitespace for text block indent should be consistent
Code Smell
Simple string literal should be used for single line strings
Code Smell
Lambdas should not have too many lines
Code Smell
'List.remove()' should not be used in ascending 'for' loops
Code Smell
Avoid using boxed "Boolean" types directly in boolean expressions
Code Smell
"String#replace" should be preferred to "String#replaceAll"
Code Smell
Collection constructors should not be used as java.util.function.Function
Code Smell
"else" statements should be clearly matched with an "if"
Code Smell
Use Java 14 "switch" expression
Code Smell
"Bean Validation" (JSR 380) should be properly configured
Code Smell
Type parameters should not shadow other type parameters
Code Smell
Derived exceptions should not hide their parents' catch blocks
Code Smell
The upper bound of type variables and wildcards should not be "final"
Code Smell
"read(byte[],int,int)" should be overridden
Code Smell
"serialVersionUID" should not be declared blindly
Code Smell
"Class.forName()" should not load JDBC 4.0+ drivers
Code Smell
An iteration on a Collection should be performed on the type handled by the Collection
Code Smell
Java features should be preferred to Guava
Code Smell
"StandardCharsets" constants should be preferred
Code Smell
"@CheckForNull" or "@Nullable" should not be used on primitive types
Code Smell
String offset-based methods should be preferred for finding substrings from offsets
Code Smell
Spring beans should be considered by "@ComponentScan"
Code Smell
"@EnableAutoConfiguration" should be fine-tuned
Code Smell
Enum values should be compared with "=="
Code Smell
"default" clauses should be last
Code Smell
Composed "@RequestMapping" variants should be preferred
Code Smell
"equals" method parameters should not be marked "@Nonnull"
Code Smell
Nullness of parameters should be guaranteed
Code Smell
"Integer.toHexString" should not be used to build hexadecimal strings
Code Smell
"write(byte[],int,int)" should be overridden
Code Smell
Spring components should use constructor injection
Code Smell
Functional Interfaces should be as specialised as possible
Code Smell
Asserts should not be used to check the parameters of a public method
Code Smell
"Stream.collect()" calls should not be redundant
Code Smell
Regex patterns should not be created needlessly
Code Smell
Null checks should not be used with "instanceof"
Code Smell
Local constants should follow naming conventions for constants
Code Smell
Assignments should not be redundant
Code Smell
Methods should not have identical implementations
Code Smell
"close()" calls should not be redundant
Code Smell
"ThreadLocal.withInitial" should be preferred
Code Smell
"java.nio.Files#delete" should be preferred
Code Smell
"Stream" call chains should be simplified when possible
Code Smell
Packages containing only "package-info.java" should be removed
Code Smell
Track uses of disallowed constructors
Code Smell
Unused "private" classes should be removed
Code Smell
A conditionally executed single line should be denoted by indentation
Code Smell
Conditionals should start on new lines
Code Smell
Number patterns should be regular
Code Smell
Arrays should not be created for varargs parameters
Code Smell
"Stream.peek" should be used with caution
Code Smell
"Map.get" and value test should be replaced with single method call
Code Smell
Cognitive Complexity of methods should not be too high
Code Smell
"@RequestMapping" methods should not be "private"
Code Smell
Members of Spring components should be injected
Code Smell
Raw types should not be used
Code Smell
Java 8's "Files.exists" should not be used
Code Smell
Track uses of disallowed classes
Code Smell
Unit tests should throw exceptions
Code Smell
"Arrays.stream" should be used for primitive arrays
Code Smell
Jump statements should not be redundant
Code Smell
Test methods should comply with a naming convention
Code Smell
Test classes should comply with a naming convention
Code Smell
"Optional" should not be used for parameters
Code Smell
Methods returns should not be invariant
Code Smell
Format strings should be used correctly
Code Smell
Value-based objects should not be serialized
Code Smell
Loggers should be named for their enclosing classes
Code Smell
Assertion arguments should be passed in the correct order
Code Smell
Tests should be kept in a dedicated source directory
Code Smell
Methods should not return constants
Code Smell
"private" methods called only by inner classes should be moved to those classes
Code Smell
"this" should not be exposed from constructors
Code Smell
Ternary operators should not be nested
Code Smell
Factory method injection should be used in "@Configuration" classes
Code Smell
Default annotation parameter values should not be passed as arguments
Code Smell
"static" base class members should not be accessed via derived types
Code Smell
Method parameters should be declared with base types
Code Smell
"enum" fields should not be publicly mutable
Code Smell
Fields should not be initialized to default values
Code Smell
Multiple loops over the same set should be combined
Code Smell
"writeObject" should not be the only "synchronized" code in a class
Code Smell
Abstract methods should not be redundant
Code Smell
Classes should not have too many "static" imports
Code Smell
"ThreadGroup" should not be used
Code Smell
Arrays and lists should not be copied using loops
Code Smell
Reflection should not be used to increase accessibility of classes, methods, or fields
Code Smell
Static fields should not be updated in constructors
Code Smell
Static non-final field names should comply with a naming convention
Code Smell
"clone" should not be overridden
Code Smell
Classes without "public" constructors should be "final"
Code Smell
Escaped Unicode characters should not be used
Code Smell
Inner classes should not have too many lines of code
Code Smell
Assertions should be complete
Code Smell
Unnecessary semicolons should be omitted
Code Smell
"Thread.sleep" should not be used in tests
Code Smell
JUnit rules should be used
Code Smell
"entrySet()" should be iterated when both the key and value are needed
Code Smell
Nested "enum"s should not be declared static
Code Smell
"catch" clauses should do more than rethrow
Code Smell
"DateUtils.truncate" from Apache Commons Lang library should not be used
Code Smell
Literal boolean values and nulls should not be used in assertions
Code Smell
Tests should include assertions
Code Smell
Test assertions should include messages
Code Smell
Instance methods should not write to "static" fields
Code Smell
Inner classes which do not reference their owning classes should be "static"
Code Smell
Threads should not be started in constructors
Code Smell
"indexOf" checks should not be for positive numbers
Code Smell
Multiline blocks should be enclosed in curly braces
Code Smell
"readObject" should not be "synchronized"
Code Smell
Method overrides should not change contracts
Code Smell
"Preconditions" and logging arguments should not require evaluation
Code Smell
Boolean expressions should not be gratuitous
Code Smell
Whitespace and control characters in literals should be explicit
Code Smell
"null" should not be returned from a "Boolean" method
Code Smell
Lazy initialization of "static" fields should be "synchronized"
Code Smell
Synchronizing on a "Lock" object should be avoided
Code Smell
Classes with only "static" methods should not be instantiated
Code Smell
"Thread" should not be used where a "Runnable" argument is expected
Code Smell
Unnecessary bit operations should not be performed
Code Smell
Inner class calls to super class methods should be unambiguous
Code Smell
Child class fields should not shadow parent class fields
Code Smell
Mutable fields should not be "public static"
Code Smell
Private mutable members should not be stored or returned directly
Code Smell
Redundant modifiers should not be used
Code Smell
Unused type parameters should be removed
Code Smell
"private" and "final" methods that don't access instance data should be "static"
Code Smell
Files should not be empty
Code Smell
"deleteOnExit" should not be used
Code Smell
Public methods should not contain selector arguments
Code Smell
The diamond operator ("<>") should be used
Code Smell
"Object.wait(...)" and "Condition.await(...)" should be called inside a "while" loop
Code Smell
Java parser failure
Code Smell
Track uses of disallowed methods
Code Smell
Collection methods with O(n) performance should be used carefully
Code Smell
"IllegalMonitorStateException" should not be caught
Code Smell
Parameters should be passed in the correct order
Code Smell
"ResultSet.isLast()" should not be used
Code Smell
"Exception" should not be caught when not required by called methods
Code Smell
Types should be used in lambdas
Code Smell
"static" members should be accessed statically
Code Smell
Wildcard imports should not be used
Code Smell
"collect" should be used with "Streams" instead of "list::add"
Code Smell
Modulus results should not be checked for direct equality
Code Smell
Switches should be used for sequences of simple "String" tests
Code Smell
JUnit test cases should call super methods
Code Smell
TestCases should contain tests
Code Smell
JUnit assertions should not be used in "run" methods
Code Smell
Do not perform unnecessary mathematical operations
Code Smell
Short-circuit logic should be used in boolean contexts
Code Smell
Class names should not shadow interfaces or superclasses
Code Smell
Classes named like "Exception" should extend "Exception" or a subclass
Code Smell
"finalize" should not set fields to "null"
Code Smell
Subclasses that add fields to classes that override "equals" should also override "equals"
Code Smell
"Cloneables" should implement "clone"
Code Smell
"final" classes should not have "protected" members
Code Smell
Underscores should be used to make large numbers readable
Code Smell
Catches should be combined
Code Smell
"java.time" classes should be used for dates and times
Code Smell
Methods of "Random" that return floating point values should not be used in random integer generation
Code Smell
Exceptions should be either logged or rethrown but not both
Code Smell
Objects should not be created only to invoke "getClass"
Code Smell
Primitives should not be boxed just for "String" conversion
Code Smell
Parsing should be used to convert "Strings" to primitives
Code Smell
Constructors should not be used to instantiate "String", "BigInteger", "BigDecimal" and primitive-wrapper classes
Code Smell
"URL.hashCode" and "URL.equals" should be avoided
Code Smell
"main" should not "throw" anything
Code Smell
Classes should not be empty
Code Smell
Try-with-resources should be used
Code Smell
Fields in non-serializable classes should not be "transient"
Code Smell
Comparators should be "Serializable"
Code Smell
"readResolve" methods should be inheritable
Code Smell
"Serializable" inner classes of "Serializable" classes should be static
Code Smell
"Serializable" classes should have a "serialVersionUID"
Code Smell
The names of methods with boolean return values should start with "is" or "has"
Code Smell
Member variable visibility should be specified
Code Smell
Files should contain only one top-level class or interface each
Code Smell
"for" loop increment clauses should modify the loops' counters
Code Smell
Fields in a "Serializable" class should either be transient or serializable
Code Smell
Classes and methods that rely on the default system encoding should not be used
Code Smell
Simple class names should be used
Code Smell
Variables should not be declared before they are relevant
Code Smell
Boolean checks should not be inverted
Code Smell
Extensions and implementations should not be redundant
Code Smell
Redundant casts should not be used
Code Smell
"@Deprecated" code should not be used
Code Smell
Two branches in a conditional structure should not have exactly the same implementation
Code Smell
"toString()" should never be called on a String object
Code Smell
Unused assignments should be removed
Code Smell
Methods and field names should not be the same or differ only by capitalization
Code Smell
"Object.wait" should not be called on objects that implement "java.util.concurrent.locks.Condition"
Code Smell
"switch" statements and expressions should not be nested
Code Smell
Classes should not have too many fields
Code Smell
The ternary operator should not be used
Code Smell
Standard functional interfaces should not be redefined
Code Smell
Annotation repetitions should not be wrapped
Code Smell
A field should not duplicate the name of its containing class
Code Smell
Constructors should only call non-overridable methods
Code Smell
"==" and "!=" should not be used when "equals" is overridden
Code Smell
"NullPointerException" should not be caught
Code Smell
"NullPointerException" should not be explicitly thrown
Code Smell
An abstract class should have both abstract and concrete methods
Code Smell
Multiple variables should not be declared on the same line
Code Smell
Strings should not be concatenated using '+' in a loop
Code Smell
Sets with elements that are enum values should be replaced with EnumSet
Code Smell
Maps with keys that are enum values should use the EnumMap implementation
Code Smell
Lambdas should be replaced with method references
Code Smell
Parentheses should be removed from a single lambda parameter when its type is inferred
Code Smell
Abstract classes without fields should be converted to interfaces
Code Smell
JUnit4 @Ignored and JUnit5 @Disabled annotations should be used to disable tests and should provide a rationale
Code Smell
Anonymous inner classes containing only one method should become lambdas
Code Smell
Lambdas containing only one statement should not nest this statement in a block
Code Smell
Package declaration should match source file directory
Code Smell
"Collections.EMPTY_LIST", "EMPTY_MAP", and "EMPTY_SET" should not be used
Code Smell
Methods should not be too complex
Code Smell
Local variables should not be declared and then immediately returned or thrown
Code Smell
Unused local variables should be removed
Code Smell
"switch" statements should not have too many "case" clauses
Code Smell
Generic wildcard types should not be used in return types
Code Smell
Track lack of copyright and license headers
Code Smell
Private fields only used as local variables in methods should become local variables
Code Smell
String operations should not rely on the default system locale
Code Smell
Classes should not have too many methods
Code Smell
"public static" fields should be constant
Code Smell
Comments should not be located at the end of lines of code
Code Smell
Methods should not have too many lines
Code Smell
Loops should not contain more than a single "break" or "continue" statement
Code Smell
Control flow statements "if", "for", "while", "switch" and "try" should not be nested too deeply
Code Smell
Declarations should use Java collection interfaces such as "List" rather than specific implementation classes such as "LinkedList"
Code Smell
Track uses of "CHECKSTYLE:OFF" suppression comments
Code Smell
Octal values should not be used
Code Smell
Loggers should be "private static final" and should share a naming convention
Code Smell
Track uses of "NOPMD" suppression comments
Code Smell
"switch" statements should have "default" clauses
Code Smell
Track uses of "@SuppressWarnings" annotations
Code Smell
"switch" statements should have at least 3 "case" clauses
Code Smell
Track uses of "NOSONAR" comments
Code Smell
Switch cases should end with an unconditional "break" statement
Code Smell
"for" loop stop conditions should be invariant
Code Smell
A "while" loop should be used instead of a "for" loop
Code Smell
"if ... else if" constructs should end with "else" clauses
Code Smell
Classes and enums with private members should have a constructor
Code Smell
Sections of code should not be commented out
Code Smell
Track comments matching a regular expression
Code Smell
Packages should have a javadoc file 'package-info.java'
Code Smell
Non-constructor methods should not have the same name as the enclosing class
Code Smell
The default unnamed package should not be used
Code Smell
Statements should be on separate lines
Code Smell
"switch" statements should not contain non-case labels
Code Smell
Execution of the Garbage Collector should be triggered only by the JVM
Code Smell
Interfaces should not solely consist of constants
Code Smell
The members of an interface or class declaration should appear in a pre-defined order
Code Smell
"equals(Object obj)" should be overridden along with the "compareTo(T obj)" method
Code Smell
Control structures should use curly braces
Code Smell
Classes should not be coupled to too many other classes
Code Smell
Package names should comply with a naming convention
Code Smell
Nested code blocks should not be used
Code Smell
Array designators "[]" should be on the type, not the variable
Code Smell
Array designators "[]" should be located after the type in method signatures
Code Smell
"java.lang.Error" should not be extended
Code Smell
Exception types should not be tested using "instanceof" in catch blocks
Code Smell
String literals should not be duplicated
Code Smell
Classes from "sun.*" packages should not be used
Code Smell
Future keywords should not be used as names
Code Smell
Type parameter names should comply with a naming convention
Code Smell
Anonymous classes should not have too many lines
Code Smell
Methods should not be empty
Code Smell
Overriding methods should do more than simply call the same method in the super class
Code Smell
Classes that override "clone" should be "Cloneable" and call "super.clone()"
Code Smell
Throwable and Error should not be caught
Code Smell
Abstract class names should comply with a naming convention
Code Smell
Public types, methods and fields (API) should be documented with Javadoc
Code Smell
"Object.finalize()" should remain protected (versus public) when overriding
Code Smell
Unused method parameters should be removed
Code Smell
Only static class initializers should be used
Code Smell
Public constants and fields initialized at declaration should be "static final" rather than merely "final"
Code Smell
Local variable and method parameter names should comply with a naming convention
Code Smell
Empty arrays and collections should be returned instead of null
Code Smell
Exception handlers should preserve the original exceptions
Code Smell
Exception classes should have final fields
Code Smell
Exceptions should not be thrown in finally blocks
Code Smell
Checked exceptions should not be thrown
Code Smell
"@Override" should be used on overriding and implementing methods
Code Smell
Public methods should throw at most one checked exception
Code Smell
Field names should comply with a naming convention
Code Smell
Primitive wrappers should not be instantiated only for "toString" or "compareTo" calls
Code Smell
Case insensitive string comparisons should be made without intermediate upper or lower casing
Code Smell
"Collection.isEmpty()" should be used to test for emptiness
Code Smell
"String.valueOf()" should not be appended to a "String"
Code Smell
"switch case" clauses should not have too many lines of code
Code Smell
"Enumeration" should not be implemented
Code Smell
Constant names should comply with a naming convention
Code Smell
Synchronized classes "Vector", "Hashtable", "Stack" and "StringBuffer" should not be used
Code Smell
Exit methods should not be called
Code Smell
Unused "private" methods should be removed
Code Smell
Methods should not have too many return statements
Code Smell
Try-catch blocks should not be nested
Code Smell
Interface names should comply with a naming convention
Code Smell
Track uses of "TODO" tags
Code Smell
Track uses of "FIXME" tags
Code Smell
Deprecated code should be removed
Code Smell
Strings literals should be placed on the left side when checking for equality
Code Smell
Exceptions in "throws" clauses should not be superfluous
Code Smell
Files should end with a newline
Code Smell
Unnecessary imports should be removed
Code Smell
Return of boolean expressions should not be wrapped into an "if-then-else" statement
Code Smell
Boolean literals should not be redundant
Code Smell
Modifiers should be declared in the correct order
Code Smell
Deprecated elements should have both the annotation and the Javadoc tag
Code Smell
Assignments should not be made from within sub-expressions
Code Smell
Source code should be indented consistently
Code Smell
Generic exceptions should never be thrown
Code Smell
Labels should not be used
Code Smell
Utility classes should not have public constructors
Code Smell
Local variables should not shadow class fields
Code Smell
Empty statements should be removed
Code Smell
The "Object.finalize()" method should not be overridden
Code Smell
Redundant pairs of parentheses should be removed
Code Smell
A close curly brace should be located at the beginning of a line
Code Smell
Close curly brace and the next "else", "catch" and "finally" keywords should be on two different lines
Code Smell
Close curly brace and the next "else", "catch" and "finally" keywords should be located on the same line
Code Smell
An open curly brace should be located at the beginning of a line
Code Smell
An open curly brace should be located at the end of a line
Code Smell
Class variable fields should not have public accessibility
Code Smell
Inheritance tree of classes should not be too deep
Code Smell
Magic numbers should not be used
Code Smell
Nested blocks of code should not be left empty
Code Smell
URIs should not be hardcoded
Code Smell
Methods should not have too many parameters
Code Smell
Unused "private" fields should be removed
Code Smell
Expressions should not be too complex
Code Smell
Mergeable "if" statements should be combined
Code Smell
Unused labels should be removed
Code Smell
Standard outputs should not be used directly to log anything
Code Smell
Tabulation characters should not be used
Code Smell
Files should not have too many lines of code
Code Smell
Lines should not be too long
Code Smell
Class names should comply with a naming convention
Code Smell
Method names should comply with a naming convention
Code Smell

Methods returning "Page" or "Slice" must take "Pageable" as an input parameter

consistency - conventional

maintainability

reliability

security

Code Smell

spring

Why is this an issue?

How can I fix it?

More Info

Spring Data Repository supports paging for queries, allowing you to return results in small, manageable chunks rather than retrieving an entire large result set.

The conventional approach to paginating data in Spring is to use the Pageable interface to control pagination and to store the query results into a Page or Slice. If a query method in a Repository returns a Page or Slice without taking a Pageable as an input, it raises a runtime exception.

This rule raises an issue on queries in a Repository that return a Page or Slice without taking a Pageable as an input.

Available In:

Catch issues on the fly,
in your IDE

Detect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories

Analyze code in your
on-premise CI

© 2008-2025 SonarSource SA. All rights reserved. SONAR, SONARSOURCE, SONARQUBE, and CLEAN AS YOU CODE are trademarks of SonarSource SA.

Sonar helps developers write Clean Code.
Privacy Policy | Cookie Policy | Terms of Use

In-IDE

SaaS

Self-Hosted